ஜாவாஸ்கிரிப்ட் அசிங்க் இட்டரேட்டர் ஹெல்பர்: ஃபார் ஈச் - ஸ்ட்ரீம் செயலாக்க மறுசெய்கை

ஒத்திசைவற்ற நிரலாக்கம் நவீன ஜாவாஸ்கிரிப்ட் மேம்பாட்டின் ஒரு மூலக்கல்லாகும், இது மெயின் த்ரெட்டைத் தடுக்காமல் நேரத்தைச் செலவழிக்கும் செயல்பாடுகளைக் கையாள பயன்பாடுகளை அனுமதிக்கிறது. ECMAScript 2018-ல் அறிமுகப்படுத்தப்பட்ட அசிங்க் இட்டரேட்டர்கள், தரவு ஸ்ட்ரீம்களை ஒத்திசைவற்ற முறையில் செயலாக்க ஒரு சக்திவாய்ந்த வழிமுறையை வழங்குகின்றன. இந்த வலைப்பதிவு இடுகை அசிங்க் இட்டரேட்டர்களின் கருத்தை ஆராய்ந்து, ஸ்ட்ரீம் செயலாக்கத்தை நெறிப்படுத்த ஒரு ஒத்திசைவற்ற 'ஃபார் ஈச்' உதவி செயல்பாட்டை எவ்வாறு செயல்படுத்துவது என்பதைக் காட்டுகிறது.

அசிங்க் இட்டரேட்டர்களைப் புரிந்துகொள்ளுதல்

ஒரு அசிங்க் இட்டரேட்டர் என்பது AsyncIterator இடைமுகத்துடன் இணங்கும் ஒரு பொருளாகும். இது ஒரு next() முறையை வரையறுக்கிறது, இது ஒரு ப்ராமிஸை வழங்குகிறது, இது இரண்டு பண்புகளுடன் ஒரு பொருளாகத் தீர்க்கப்படுகிறது:

• மதிப்பு: வரிசையில் அடுத்த மதிப்பு.
• முடிந்தது: இட்டரேட்டர் முடிந்துவிட்டதா என்பதைக் குறிக்கும் ஒரு பூலியன்.

அசிங்க் இட்டரேட்டர்கள் பொதுவாக நெட்வொர்க் ஸ்ட்ரீம்கள், கோப்பு முறைமைகள் அல்லது தரவுத்தளங்கள் போன்ற ஒத்திசைவற்ற மூலங்களிலிருந்து தரவைப் பயன்படுத்தப் பயன்படுகின்றன. for await...of லூப், அசிங்க் இட்டரபிள்களை மறுசெய்கை செய்ய ஒரு வசதியான தொடரியலை வழங்குகிறது.

உதாரணம்: ஒரு கோப்பிலிருந்து ஒத்திசைவற்ற முறையில் படித்தல்

மெயின் த்ரெட்டைத் தடுக்காமல் ஒரு பெரிய கோப்பை வரியாகப் படிக்க வேண்டிய ஒரு சூழ்நிலையைக் கவனியுங்கள். இதை ஒரு அசிங்க் இட்டரேட்டரைப் பயன்படுத்தி நீங்கள் அடையலாம்:

            
const fs = require('fs');
const readline = require('readline');

async function* readFileLines(filePath) {
  const fileStream = fs.createReadStream(filePath);
  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    yield line;
  }
}

async function processFile(filePath) {
  for await (const line of readFileLines(filePath)) {
    console.log(`Line: ${line}`);
  }
}

// Example usage
processFile('path/to/your/file.txt');

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், readFileLines என்பது ஒரு அசிங்க் ஜெனரேட்டர் செயல்பாடாகும், இது கோப்பின் ஒவ்வொரு வரியையும் படிக்கும்போது கொடுக்கிறது. பின்னர் processFile செயல்பாடு for await...of ஐப் பயன்படுத்தி வரிகளை மறுசெய்கை செய்கிறது, ஒவ்வொரு வரியையும் ஒத்திசைவற்ற முறையில் செயலாக்குகிறது.

ஒரு அசிங்க் 'ஃபார் ஈச்' ஹெல்பரை செயல்படுத்துதல்

for await...of லூப் பயனுள்ளதாக இருந்தாலும், ஸ்ட்ரீமில் உள்ள ஒவ்வொரு உறுப்பிலும் சிக்கலான செயல்பாடுகளைச் செய்ய வேண்டியிருக்கும் போது அது விரிவானதாக மாறும். ஒரு அசிங்க் 'ஃபார் ஈச்' உதவி செயல்பாடு, மறுசெய்கை தர்க்கத்தை இணைப்பதன் மூலம் இந்த செயல்முறையை எளிதாக்க முடியும்.

அடிப்படைச் செயலாக்கம்

ஒரு அசிங்க் 'ஃபார் ஈச்' செயல்பாட்டின் அடிப்படைச் செயலாக்கம் இங்கே:

            
async function asyncForEach(iterable, callback) {
  for await (const item of iterable) {
    await callback(item);
  }
}

            

              
                Copy
              
            
          

இந்தச் செயல்பாடு ஒரு அசிங்க் இட்டரபிள் மற்றும் ஒரு கால்பேக் செயல்பாட்டை தருமதிகளாக எடுத்துக்கொள்கிறது. இது for await...of ஐப் பயன்படுத்தி இட்டரபிளை மறுசெய்கை செய்கிறது மற்றும் ஒவ்வொரு உருப்படிக்கும் கால்பேக் செயல்பாட்டை அழைக்கிறது. அடுத்த உருப்படிக்குச் செல்வதற்கு முன் அதன் நிறைவுக்காக நீங்கள் காத்திருக்க விரும்பினால், கால்பேக் செயல்பாடும் ஒத்திசைவற்றதாக இருக்க வேண்டும்.

உதாரணம்: ஒரு API-இலிருந்து தரவைச் செயலாக்குதல்

உருப்படிகளின் ஸ்ட்ரீமை வழங்கும் ஒரு API-இலிருந்து நீங்கள் தரவைப் பெறுகிறீர்கள் என்று வைத்துக்கொள்வோம். ஒவ்வொரு உருப்படியும் வரும்போது அதைச் செயலாக்க அசிங்க் 'ஃபார் ஈச்' ஹெல்பரைப் பயன்படுத்தலாம்:

            
async function* fetchDataStream(url) {
  const response = await fetch(url);
  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        return;
      }

      // Assuming the API returns JSON chunks
      const chunk = decoder.decode(value);
      const items = JSON.parse(`[${chunk.replace(/\}\{/g, '},{')}]`); //Split chunks into valid json array

      for(const item of items){
        yield item;
      }
    }
  } finally {
    reader.releaseLock();
  }
}

async function processItem(item) {
  // Simulate an asynchronous operation
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log(`Processing item: ${JSON.stringify(item)}`);
}

async function main() {
  const apiUrl = 'https://api.example.com/data'; // Replace with your API endpoint
  await asyncForEach(fetchDataStream(apiUrl), processItem);
  console.log('Finished processing data.');
}

// Example usage
main();

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், fetchDataStream ஆனது API-இலிருந்து தரவைப் பெற்று, பெறப்பட்ட ஒவ்வொரு உருப்படியையும் கொடுக்கிறது. processItem செயல்பாடு ஒவ்வொரு உருப்படியிலும் ஒரு ஒத்திசைவற்ற செயல்பாட்டை உருவகப்படுத்துகிறது. பின்னர் asyncForEach ஹெல்பர் மறுசெய்கை மற்றும் செயலாக்க தர்க்கத்தை எளிதாக்குகிறது.

மேம்பாடுகள் மற்றும் கருத்தில் கொள்ள வேண்டியவை

பிழை கையாளுதல்

ஒத்திசைவற்ற மறுசெய்கையின் போது ஏற்படக்கூடிய பிழைகளைக் கையாள்வது மிகவும் முக்கியம். விதிவிலக்குகளைப் பிடிக்கவும் கையாளவும் நீங்கள் கால்பேக் செயல்பாட்டை ஒரு try...catch பிளாக்கில் வைக்கலாம்:

            
async function asyncForEach(iterable, callback) {
  for await (const item of iterable) {
    try {
      await callback(item);
    } catch (error) {
      console.error(`Error processing item: ${item}`, error);
      // You can choose to re-throw the error or continue processing
    }
  }
}

            

              
                Copy
              
            
          

ஒரேநேரக் கட்டுப்பாடு (Concurrency Control)

இயல்பாக, அசிங்க் 'ஃபார் ஈச்' ஹெல்பர் உருப்படிகளை வரிசையாகச் செயலாக்குகிறது. நீங்கள் உருப்படிகளை ஒரே நேரத்தில் செயலாக்க விரும்பினால், ஒரே நேரத்தில் நிகழும் செயல்பாடுகளின் எண்ணிக்கையைக் கட்டுப்படுத்த ஒரு ப்ராமிஸ் பூலைப் பயன்படுத்தலாம்:

            
async function asyncForEachConcurrent(iterable, callback, concurrency) {
  const executing = [];
  for await (const item of iterable) {
    const p = callback(item).then(() => executing.splice(executing.indexOf(p), 1));
    executing.push(p);
    if (executing.length >= concurrency) {
      await Promise.race(executing);
    }
  }
  await Promise.all(executing);
}

async function processItem(item) {
  // Simulate an asynchronous operation
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log(`Processing item: ${JSON.stringify(item)}`);
}

async function main() {
  const apiUrl = 'https://api.example.com/data'; // Replace with your API endpoint
  await asyncForEachConcurrent(fetchDataStream(apiUrl), processItem, 5); // Concurrency of 5
  console.log('Finished processing data.');
}

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், asyncForEachConcurrent ஒரே நேரத்தில் நிகழும் கால்பேக் செயல்பாடுகளின் எண்ணிக்கையை குறிப்பிட்ட ஒரேநேர நிலைக்குக் கட்டுப்படுத்துகிறது. பெரிய தரவு ஸ்ட்ரீம்களைக் கையாளும் போது இது செயல்திறனை மேம்படுத்தும்.

ரத்துசெய்தல்

சில சமயங்களில், மறுசெய்கை செயல்முறையை முன்கூட்டியே ரத்து செய்ய வேண்டியிருக்கும். இதை ஒரு AbortController ஐப் பயன்படுத்தி நீங்கள் அடையலாம்:

            
async function asyncForEach(iterable, callback, signal) {
  for await (const item of iterable) {
    if (signal && signal.aborted) {
      console.log('Iteration aborted.');
      return;
    }
    await callback(item);
  }
}

async function main() {
  const controller = new AbortController();
  const signal = controller.signal;

  setTimeout(() => {
    controller.abort(); // Abort after 2 seconds
  }, 2000);

  const apiUrl = 'https://api.example.com/data'; // Replace with your API endpoint
  await asyncForEach(fetchDataStream(apiUrl), processItem, signal);
  console.log('Finished processing data.');
}

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், asyncForEach செயல்பாடு ஒவ்வொரு மறுசெய்கைக்கு முன்பும் signal.aborted பண்பைச் சரிபார்க்கிறது. சிக்னல் ரத்து செய்யப்பட்டால், மறுசெய்கை நிறுத்தப்படும்.

நிஜ-உலகப் பயன்பாடுகள்

அசிங்க் இட்டரேட்டர்கள் மற்றும் அசிங்க் 'ஃபார் ஈச்' ஹெல்பர் பலதரப்பட்ட நிஜ-உலக சூழ்நிலைகளுக்குப் பயன்படுத்தப்படலாம்:

• தரவு செயலாக்க பைப்லைன்கள்: தரவுத்தளங்கள் அல்லது கோப்பு முறைமைகளிலிருந்து பெரிய தரவுத்தொகுப்புகளைச் செயலாக்குதல்.
• நிகழ்நேர தரவு ஸ்ட்ரீம்கள்: வெப் சாக்கெட்டுகள், மெசேஜ் க்யூக்கள் அல்லது சென்சார் நெட்வொர்க்குகளிலிருந்து தரவைக் கையாளுதல்.
• API நுகர்வு: உருப்படிகளின் ஸ்ட்ரீம்களை வழங்கும் API-களிலிருந்து தரவைப் பெறுதல் மற்றும் செயலாக்குதல்.
• படம் மற்றும் வீடியோ செயலாக்கம்: பெரிய மீடியா கோப்புகளை துண்டுகளாகச் செயலாக்குதல்.
• பதிவுப் பகுப்பாய்வு (Log analysis): பெரிய பதிவு கோப்புகளை வரியாகப் பகுப்பாய்வு செய்தல்.

உதாரணம் - சர்வதேச பங்குத் தரவு: பல்வேறு சர்வதேசப் பங்குச் சந்தைகளிலிருந்து நிகழ்நேரப் பங்கு விலைகளைப் பெறும் ஒரு பயன்பாட்டைக் கவனியுங்கள். தரவை ஸ்ட்ரீம் செய்ய ஒரு அசிங்க் இட்டரேட்டரைப் பயன்படுத்தலாம், மற்றும் ஒவ்வொரு மேற்கோளையும் செயலாக்க ஒரு அசிங்க் 'ஃபார் ஈச்' ஐப் பயன்படுத்தலாம், இது பயனர் இடைமுகத்தை சமீபத்திய விலைகளுடன் புதுப்பிக்கும். இது போன்ற நிறுவனங்களின் தற்போதைய பங்கு விகிதங்களைக் காட்டப் பயன்படுத்தப்படலாம்:

• டென்சென்ட் (சீனா): ஒரு முக்கிய சர்வதேச தொழில்நுட்ப நிறுவனத்தின் பங்குத் தரவைப் பெறுதல்
• டாடா கன்சல்டன்சி சர்வீசஸ் (இந்தியா): ஒரு முன்னணி தகவல் தொழில்நுட்ப சேவை நிறுவனத்தின் பங்குப் புதுப்பிப்புகளைக் காண்பித்தல்
• சாம்சங் எலக்ட்ரானிக்ஸ் (தென் கொரியா): ஒரு உலகளாவிய எலக்ட்ரானிக்ஸ் உற்பத்தியாளரிடமிருந்து பங்கு விகிதங்களைக் காண்பித்தல்
• டொயோட்டா மோட்டார் கார்ப்பரேஷன் (ஜப்பான்): ஒரு சர்வதேச வாகன உற்பத்தியாளரின் பங்கு விலைகளைக் கண்காணித்தல்

முடிவுரை

அசிங்க் இட்டரேட்டர்கள் மற்றும் அசிங்க் 'ஃபார் ஈச்' ஹெல்பர் ஆகியவை ஜாவாஸ்கிரிப்டில் தரவு ஸ்ட்ரீம்களை ஒத்திசைவற்ற முறையில் செயலாக்க ஒரு சக்திவாய்ந்த மற்றும் நேர்த்தியான வழியை வழங்குகின்றன. மறுசெய்கை தர்க்கத்தை இணைப்பதன் மூலம், உங்கள் குறியீட்டை எளிதாக்கலாம், வாசிப்புத்திறனை மேம்படுத்தலாம் மற்றும் உங்கள் பயன்பாடுகளின் செயல்திறனை அதிகரிக்கலாம். பிழைகளைக் கையாளுதல், ஒரேநேரக் கட்டுப்பாட்டை நிர்வகித்தல் மற்றும் ரத்துசெய்தலை இயக்குவதன் மூலம், நீங்கள் வலுவான மற்றும் அளவிடக்கூடிய ஒத்திசைவற்ற தரவு செயலாக்க பைப்லைன்களை உருவாக்கலாம்.

மேலும் கற்க

• MDN வலை ஆவணங்கள்: for await...of
• MDN வலை ஆவணங்கள்: async function*
• ECMAScript விவரக்குறிப்பு: AsyncIterator இடைமுகம்